home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / pascal / p_mat.exe / PMAT.DOC < prev    next >
Text File  |  1993-01-24  |  49KB  |  1,311 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  
  17.  
  18.           P-Mat v1.2
  19.           An Turbo Pascal program for Recursive Matrix Algebra
  20.  
  21.           Mark Von Tress, Ph.D.
  22.  
  23.  
  24.  
  25.  
  26.  
  27.  
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.  
  44.  
  45.           PO Box 171173
  46.           Arlington TX 76003
  47.  
  48.  
  49.           Compuserve User ID : 71530,1170
  50.  
  51.  
  52.           Date: January 30, 1993
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.           You are responsible for what you do with the
  61.           code. Here is a formal disclaimer:
  62.  
  63.  
  64.           DISCLAIMER: THIS PROGRAM IS PROVIDED AS IS, WITHOUT ANY
  65.           WARRANTY, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
  66.           TO FITNESS FOR A PARTICULAR PURPOSE. THE AUTHOR DISCLAIMS
  67.           ALL LIABILITY FOR DIRECT OR CONSEQUENTIAL DAMAGES RESULTING
  68.           FROM USE OF THIS PROGRAM.
  69.  
  70.  
  71.           Copyright (c) Mark Von Tress 1993
  72.  
  73.  
  74.  
  75.  
  76.  
  77.           Mat-P 3
  78.  
  79.  
  80.                                   Table of Contents
  81.  
  82.  
  83.           I. INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . .   4
  84.  
  85.           II. FINANCIAL CONDITIONS OF USE . . . . . . . . . . . . . . .   4
  86.  
  87.           III. BASIC ALGORITHMS . . . . . . . . . . . . . . . . . . . .   5
  88.                A. Structures and Allocation . . . . . . . . . . . . . .   5
  89.                B. The global stack: dispatch  . . . . . . . . . . . . .   7
  90.                C. Recursion . . . . . . . . . . . . . . . . . . . . . .   7
  91.                D. Matrix Assignment . . . . . . . . . . . . . . . . . .   8
  92.                E. Parameter Passing . . . . . . . . . . . . . . . . . .   9
  93.  
  94.           IV. FUNCTIONS . . . . . . . . . . . . . . . . . . . . . . . .  10
  95.                A. Error Handling  . . . . . . . . . . . . . . . . . . .  10
  96.                B. Array Allocation or Deallocation  . . . . . . . . . .  11
  97.                C. Stack Control . . . . . . . . . . . . . . . . . . . .  11
  98.                D. Matrix Allocation, Deallocation and Copy  . . . . . .  13
  99.                E. Display Functions . . . . . . . . . . . . . . . . . .  14
  100.                F. Matrix IO . . . . . . . . . . . . . . . . . . . . . .  15
  101.                G. Binary Matrix Functions . . . . . . . . . . . . . . .  16
  102.                H. Unary Matrix Functions  . . . . . . . . . . . . . . .  17
  103.                I. Patterned Matrices  . . . . . . . . . . . . . . . . .  19
  104.                J. Mathematical Functions  . . . . . . . . . . . . . . .  20
  105.  
  106.           V. COMPILATION AND LIMITATIONS  . . . . . . . . . . . . . . .  24
  107.  
  108.           VI. REVISION HISTORY  . . . . . . . . . . . . . . . . . . . .  25
  109.                A.  Version 1.0  . . . . . . . . . . . . . . . . . . . .  25
  110.                B.  Version 1.1  . . . . . . . . . . . . . . . . . . . .  25
  111.                C.  Version 1.2  . . . . . . . . . . . . . . . . . . . .  25
  112.  
  113.  
  114.  
  115.  
  116.  
  117.           Mat-P 4
  118.  
  119.  
  120.           I. INTRODUCTION
  121.  
  122.  
  123.  
  124.           PMAT is Turbo Pascal (TP) source code for recursive matrix
  125.           algebra.  The program is based on another program I wrote in C to
  126.           do the same thing. Both use a stack of matrices to keep track of
  127.           intermediate heap allocations. Once I figured it out in C it was
  128.           pretty easy to step back and do it in Pascal.  The object
  129.           oriented extensions in TP also helped smooth the process. This
  130.           allowed a convenient scheme to allow matrices to be larger than
  131.           64K.
  132.  
  133.           Of course you can't overload operators in TP, so the recursion is
  134.           messy. However, you can keep track of intermediate allocations on
  135.           the heap using PMAT. 
  136.  
  137.                new( a, makematrix( 1, 1 ) );
  138.                x = matequals(x, add( a,add(b,c))); 
  139.  
  140.           This code segment has to keep track of matrix allocations on the
  141.           heap, and then delete the temporary matrices. In this example,
  142.           the sum of B and C is a temporary matrix which would be lost
  143.           without some sort of global memory allocation tracking such as a
  144.           stack.  Its memory should be deleted after the equals function is
  145.           called. The stack helps avoid the assignment of temporaries in
  146.           recursive calls.
  147.  
  148.           On a more personal note, I wrote this program for fun. I started
  149.           on this problem in TP 3.0 when that was the best compiler on the
  150.           market (1984). I never really got a satisfactory answer, so I set
  151.           it down. Then I picked it up in Turbo C, and didn't get a
  152.           satisfactory answer. Then I picked it up in C++, and got a good
  153.           answer in about 1990 (see YAMP on the BPROGB of Compuserve). Then
  154.           I wrote it in C with good results, then TP 6.0 just for old times
  155.           sake. I had forgotten how fast TP compiles. It's a real code
  156.           blaster. Object oriented programming in TP 6 also helped. I guess
  157.           I learned some computer science along the way too. 
  158.  
  159.  
  160.           II. FINANCIAL CONDITIONS OF USE
  161.  
  162.  
  163.           If you like this program, send me $5.00 US (or buy a deserving
  164.           beggar lunch. In either case, find a way to repay my charity.)
  165.           You may distribute the package unchanged. I only plan to
  166.           distribute it electronically. I retain the copyright as proof of
  167.           authorship.
  168.  
  169.  
  170.  
  171.  
  172.  
  173.           Mat-P 5
  174.  
  175.           III. BASIC ALGORITHMS
  176.  
  177.  
  178.                A. Structures and Allocation
  179.  
  180.  
  181.           PMAT has two important objects: vmatrix and mstack. The vmatrix
  182.           object is declared in the interface 
  183.  
  184.                vmatrixptr = ^vmatrix;
  185.                vmatrix = Object
  186.                   r, c : integer;
  187.                   Function m( i, j: integer ): double;
  188.                   Function mm( i, j: integer ) : fp;
  189.                   constructor MakeMatrix( vr, vc: integer );
  190.                   Destructor KillVmatrix;
  191.                   Procedure Garbage;
  192.                   Procedure Show( strng: String );
  193.                   Procedure infomatrix( strng: String );
  194.  
  195.                   private
  196.                      v,vcheck: ^app;
  197.                      nelems : longint;
  198.                      onstack : boolean;
  199.                      Procedure purgevectors;
  200.                      Procedure allocvectors( rr, cc: integer );
  201.                End;
  202.  
  203.  
  204.           The vmatrix contains integers for the dimensions of the matrices,
  205.           an array of pointers to vectors of doubles, the number of
  206.           elements, and a check address. Matrix allocation is based on
  207.           Numerical Recipes in C . An array of addresses of vectors of
  208.           doubles is allocated first. Then, an array is allocated and its
  209.           first address is stored in the address vector. This method allows
  210.           matrices larger than 64K and scatters the rows of the matrix
  211.           throughout the heap. A row is restricted to 8190 doubles to keep
  212.           it under 64K. 
  213.  
  214.           Object oriented programming helped hide the ugly notation
  215.           required for storing and retrieving elements from a vmatrix. You
  216.           use the member function mm(i,j) to store elements in the matrix,
  217.           and m(i,j) to retrieve elements. An example is
  218.  
  219.                x^.mm(i,j)^ := y^.m(i,j);
  220.  
  221.           where x and y are vmatrix pointers. Note the extra ^ in
  222.           x^.mm(i,j)^. This returns the address in the heap for storing an
  223.           element. Using x^.mm(i,j) won't work. Think of element assignment
  224.           as saying "put y^.m(i,j) in the address pointed to by
  225.           x^.mm(i,j)". Using m(i,j) returns a double via
  226.  
  227.  
  228.  
  229.  
  230.  
  231.           Mat-P 6
  232.  
  233.                m := v^[i]^[j];
  234.  
  235.  
  236.           and using mm(i,j) returns an address via
  237.  
  238.               mm := @v^[i]^[j];
  239.  
  240.           Using member functions protects you from having to type these
  241.           unintuitive indexing operations. I also allows easy access to
  242.           matrices larger than 64K. They also do range checking on the
  243.           indexes.
  244.  
  245.           The check pointer contains the value of v upon allocating the
  246.           matrix. Then it is set to zero upon deallocation of v. The check
  247.           value is used in the member function Garbage(). If v does not
  248.           equal vcheck, then t